// eslint-disable/
/**
 * Created by fanGe on 2019-02-21 09:44:57.
 * 自动生成
 */

import {formateDateStr} from '@/utils/date'

/* 引入数据存储 */
import store from '@/store'
import * as devUtils from '@/utils/devUtils.js'

/**
 * 用于在时间后面添加标签
 * @param {Date} time 时间
 * @param {String} label 后缀标签
 * @returns {*} 结果
 */
function pluralize (time, label) {
  if (time === 1) {
    return time + label
  }
  return time + label + 's'
}

/**
 * 全局日期格式化
 * @param {String} value 值
 * @param {String} format 格式化字符串
 * @return {String} 字符串
 */
export function formatDateNull (value, format) {
  if (value === -2209017600000 || value === '1900-01-01') {
    return null
  } else {
    let formateStr = format || 'yyyy-MM-dd'
    return isNull(value) ? '' : (formateDateStr(new Date(value), formateStr))
  }
}

/**
 * 显示时间过去了多久
 * @param {Date} time 时间
 * @returns {*} 结果
 */
export function timeAgo (time) {
  const between = Date.now() / 1000 - Number(time)
  if (between < 3600) {
    return pluralize(~~(between / 60), ' minute')
  } else if (between < 86400) {
    return pluralize(~~(between / 3600), ' hour')
  } else {
    return pluralize(~~(between / 86400), ' day')
  }
}

/**
 * 解析时间
 * @param {Time} time 时间
 * @param {String} cFormat 格式化字符串
 * @returns {*} 结果
 */
export function parseTime (time, cFormat) {
  if (arguments.length === 0) {
    return null
  }

  if ((time + '').length === 10) {
    time = +time * 1000
  }

  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    date = new Date(parseInt(time))
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const timestr = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key]
    if (key === 'a') return ['一', '二', '三', '四', '五', '六', '日'][value - 1]
    if (result.length > 0 && value < 10) {
      value = '0' + value
    }
    return value || 0
  })
  return timestr
}

/**
 * 格式化时间
 * @param {Time} time 时间
 * @param {String} option 选项
 * @returns {*} 结果
 */
export function formatTime (time, option) {
  time = +time * 1000
  const d = new Date(time)
  const now = Date.now()

  const diff = (now - d) / 1000

  if (diff < 30) {
    return '刚刚'
  } else if (diff < 3600) {
    // less 1 hour
    return Math.ceil(diff / 60) + '分钟前'
  } else if (diff < 3600 * 24) {
    return Math.ceil(diff / 3600) + '小时前'
  } else if (diff < 3600 * 24 * 2) {
    return '1天前'
  }
  if (option) {
    return parseTime(time, option)
  } else {
    return (
      d.getMonth() +
      1 +
      '月' +
      d.getDate() +
      '日' +
      d.getHours() +
      '时' +
      d.getMinutes() +
      '分'
    )
  }
}

/**
 *  数字 格式化
 * @param {Number} num 数据
 * @param {Number} digits 小数位
 * @returns {string} 结果
 */
export function nFormatter (num, digits) {
  const si = [
    {value: 1e18, symbol: 'E'},
    {value: 1e15, symbol: 'P'},
    {value: 1e12, symbol: 'T'},
    {value: 1e9, symbol: 'G'},
    {value: 1e6, symbol: 'M'},
    {value: 1e3, symbol: 'k'}
  ]
  for (let i = 0; i < si.length; i++) {
    if (num >= si[i].value) {
      return (
        (num / si[i].value + 0.1)
          .toFixed(digits)
          .replace(/\.0+$|(\.[0-9]*[1-9])0+$/, '$1') + si[i].symbol
      )
    }
  }
  return num.toString()
}

/**
 * html转换为文本
 * @param {String} val html
 * @returns {string} text
 */
export function html2Text (val) {
  const div = document.createElement('div')
  div.innerHTML = val
  return div.textContent || div.innerText
}

/**
 * 金额格式化（千分位标记）
 * @param {Number} num 数字
 * @returns {string} 结果
 */
export function toThousandFilter (num) {
  return (+num || 0)
    .toString()
    .replace(/^-?\d+/g, m => m.replace(/(?=(?!\b)(\d{3})+$)/g, ','))
}
// //eslint-enable/

/**
 * 获取对象是否为null或undefined
 *
 * @param {Object} obj
 *            obj为null或undefined返回true，否则返回true
 */
export function isNull (obj) {
  return obj === undefined || obj === null ? 'true' : 'false'
}

/**
 * 全局日期格式化
 * @param {String} value 值
 * @param {String} format 格式化字符串
 * @return {String} 字符串
 */
export function formatDate (value, format) {
  let formateStr = format || 'yyyy-MM-dd'
  return isNull(value) ? '' : (formateDateStr(new Date(parseInt(value)), formateStr))
}

/**
 * 全局注册时间格式化函数
 * @param {String} value 值
 * @param {String} formate 格式化字符串
 * @return {String} 结果
 */
export function formatMinute (value, format) {
  let formateStr = format || 'hh:mm'
  return isNull(value) ? '' : (formateDateStr(new Date(value), formateStr))
}

export function formatDatetime (value, format) {
  let formateStr = format || 'yyyy-MM-dd hh:mm:ss'
  return isNull(value) ? '' : (formateDateStr(new Date(value), formateStr))
}

export function formatDateMinute (value, format) {
  let formateStr = format || 'yyyy-MM-dd hh:00'
  return isNull(value) ? '' : (formateDateStr(new Date(value), formateStr))
}

/**
 * 格式化字 典
 * @param {String} value 值
 * @param {String} dictTypeId 字典类型id
 * @param {String} sys 子系统
 * @return {String} 结果
 */
export function formatDict (value, dictTypeId, sys = null) {
  let r = store.state.sys.dictionarys.filter(function (dict) {
    if (sys && dict.sys !== sys) { return false }
    return dict.dictTypeCode === dictTypeId && value === dict.dictId
  })
  if (!r || r.length < 1) {
    return value
  }
  return r[0].dictName || value
}

/**
 * 获取数据源名称
 * @param {Number} value 数据源id
 * @return {String} 数据源名称
 */
export function formatDataSourceName (value) {
  let r = store.state.dev.dss.find(function (ds, index) {
    return ds.id === value
  })
  if (r) {
    return r.name || value
  }
  return value
}

/**
 * 格式化数字
 * @param {Number} value 值
 * @param {Number} decimal 小数位
 * @param {String} prefix 前缀
 * @param {String} postfix 后缀
 * @returns {string} 返回字符串
 */
export function formatNumber (value, decimal, prefix, postfix) {
  let r = ''
  if (!value) {
    return r
  }
  r = `${value}`
  if (decimal) {
    r += ',' + decimal
  }
  if (prefix) {
    r = postfix + r
  }
  if (postfix) {
    r += postfix
  }
  return r
}

/**
 * 格式化列长度
 * @param {String} value 值
 * @param {Number} decimal 小数位
 * @returns {string} 返回字符串
 */
export function formatColumnLength (value, decimal) {
  let r = formatNumber(value, decimal)
  if (r && r.indexOf(',') > 0) {
    r = `(${r})`
  }
  return r
}

/**
 * 格式化组建
 * @param {String} value 列对象
 * @param {Object} item 对象
 * @returns {*} 根据类型获取组件
 */
export function formatComponent (value, item) {
  let obj = item || value
  if (obj.component) {
    return obj.component
  } else {
    return devUtils.getColumnComponent(obj)
  }
}

/**
 * 获取java类型
 * @param {String} value 列对象
 * @param {Object} item 对象
 * @returns {*} 根据类型获取组件
 */
export function formatJavaType (value, item) {
  let obj = item || value
  if (obj.javaType && obj.javaType !== 'Any') {
    return obj.javaType
  } else {
    return devUtils.getJavaType(obj)
  }
}

/**
 * 转换为驼峰
 * @param {String} value 待转换字符串
 * @returns {*} 结果
 */
export function toCamelCase (value) {
  return devUtils.toCamelCase(value)
}

/**
 * 转换为格式化数字金额
 * @param {Number} num 待转数字金额
 * @param {Number} digits 小数位
 * @returns {*} 结果
 */

export function thousandFilter (num, digits) {
  if (typeof (num) !== 'undefined' && num !== null) {
    if (digits === null || typeof (digits) === 'undefined') {
      digits = 2
    }
    num = (+num || 0).toFixed(digits)
      .toString()
      .replace(/^-?\d+/g, m => m.replace(/(?=(?!\b)(\d{3})+$)/g, ','))
    let nums = num.split('.')
    if (nums.length === 1) {
      num += '.00'
    } else {
      if (nums[1].length === 1) {
        num += '0'
      }
    }
    return num
  } else {
    return ''
  }
}

/**
 * 全局默认时间为空
 * @param {String} value 值
 * @param {String} formate 格式化字符串
 * @return {String} 结果
 */
export function formatCheckDatetime (value, format) {
  let formateStr = format || 'yyyy-MM-dd hh:mm:ss'
  if (value === -2209017600000 || value === '1900-01-01') {
    value = null
  }
  return isNull(value) ? '' : (formateDateStr(new Date(value), formateStr))
}
/**
 * 转换为格式化数字金额 亿元
 * @param {Number} num 待转数字金额
 * @returns {*} 结果
 */

export function billionFilter (num) {
  if (typeof (num) !== 'undefined' && num !== null) {
    num = (num / 100000000).toFixed(2)
    num = (+num || 0)
      .toString()
      .replace(/^-?\d+/g, m => m.replace(/(?=(?!\b)(\d{3})+$)/g, ','))
    let nums = num.split('.')
    if (nums.length === 1) {
      num += '.00'
    } else {
      if (nums[1].length === 1) {
        num += '0'
      }
    }
    return num
  } else {
    return ''
  }
}

/**
 *  数字保留小数
 * @param {Number} num 数据
 * @param {Number} digits 小数位
 * @returns {string} 结果
 */
export function FormatNum (num, digits) {
  if (num >= 0) {
    return num.toFixed(2).toString()
  }
}

/**
 *
 * @param {*} timestamp 时间戳转换
 */
export function timestampToTime (timestamp, format) {
  let formateStr = format || 'yyyy-MM-dd'
  if (!timestamp) return ''
  var date = new Date(timestamp) // 时间戳为10位需*1000，时间戳为13位的话不需乘1000
  var Y = date.getFullYear() + '-'
  var M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-'
  var D = (date.getDate() < 10 ? '0' + date.getDate() : date.getDate()) + ' '
  var h = date.getHours() + ':' // 小时
  var m = (date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()) + ':' // 分
  var s = (date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds()) + ' ' // 秒
  if (formateStr === 'yyyy-MM-dd') {
    return Y + M + D
  } else if (formateStr === 'yyyy-MM-dd hh:mm:ss') {
    return Y + M + D + h + m + s
  }
}
